﻿namespace DataServer.ApplicationLib.Rules
{
    public class ConfigDataRuleField : ConfigDataRuleBase
    {
        public ConfigDataRuleField(RuleContext ruleContext) : base(ruleContext)
        {
        }

        public override async Task<VerifyRuleResult> VerifyData()
        {

            var result = new VerifyRuleResult()
            {
                IsValid = true,
            };

            var data = RuleContext.TargetData;

            if (data != null)
            {
                var fieldList = this.RuleContext.ConfigFieldInfos;
                var needCheckField = fieldList.Where(f => f.IsVisible).ToList();
                if (needCheckField.Any())
                {
                    RequiredModel requiredCheck = new RequiredModel();
                    foreach (var field in needCheckField)
                    {
                        try
                        {
                            if (data.Columns.Contains(field.FieldCode))
                            {
                                bool isValid = true;
                                var requiredResult = await requiredCheck.Verify(this.RuleContext, field);
                                isValid &= requiredResult.IsValid;
                                result.Message += requiredResult.Message;

                                if (!field.IgnoreCtlVerify)
                                {
                                    var controlCheckResult = field.ParaseControlVerify(RuleContext.ConfigInfo.CheckWay).Verify(RuleContext);
                                    isValid &= controlCheckResult.IsValid;
                                    result.Message += controlCheckResult.Message;
                                }
                                result.IsValid &= isValid;
                                if (!isValid)
                                {
                                    if (RuleContext.ConfigInfo.CheckWay == DataCheckWay.InDB)
                                    {
                                        RuleContext.DbUpdatedColList.Add(VerifyResultColumns.IsValid);
                                    }
                                    else
                                    {
                                        RuleContext.MemoryUpdatedColList.Add(VerifyResultColumns.IsValid);
                                    }
                                }
                            }
                        }
                        catch (Exception)
                        {

                            throw;
                        }
                    }
                    // 其他的字段规则
                    var fieldResult = RunByRuleType(data, RuleType.FieldRule, false);
                    result.Message += fieldResult.Message;

                    // 非法且没有异常消息
                    if (!result.IsValid && string.IsNullOrEmpty(result.Message))
                    {
                        result.Message = "在进行字段校验时，发现不合法的数据;";
                    }

                    // 用默认值填充不可见，可用的字段
                    //FillInvisibleDefaultData();
                    // second: do successor verify
                    if (null != Successor)
                    {
                        var successorResult = await this.Successor.VerifyData();
                        result.Message += successorResult.Message;
                    }
                }
                else
                {
                    result.Message = "没有需要校验的字段，请检测配置的字段定义;";
                }



                // 其他的字段规则
                // var fieldResult = RunByRuleType(data, RuleTypeEnum.FieldRule, false);
                // result.Message += fieldResult.Message;

                // 非法且没有异常消息
                // if (!result.IsValid && string.IsNullOrEmpty(result.Message))
                // {
                //     result.Message = "在进行字段校验时，发现不合法的数据;";
                // }

                // if (null != Successor)
                // {
                //     var successorResult = this.Successor.VerifyData();
                //     result.Message += successorResult.Message;
                // }


            }
            else
            {
                result.Message = "数据列表为空";
            }

            result.IsValid = string.IsNullOrEmpty(result.Message);

            return result;

            //VerifyResult result = new VerifyResult()
            //{
            //    IsValid = true
            //};
            //System.Data.DataTable data = this.Context.TargetData;
            //if (data != null && data.Rows.Count > 0)
            //{
            //    var fieldList = this.Context.FieldList;
            //    if (fieldList != null && fieldList.Where(f => f.IsVisiable && f.EnabledFlag).Count() > 0)
            //    {
            //        var needCheckField = fieldList.Where(f => f.IsVisiable && f.EnabledFlag).ToList();
            //        RequiredModel requiredCheck = new RequiredModel();
            //        RuleContext.Log.Info("field verify start.");
            //        foreach (var field in needCheckField)
            //        {
            //            try
            //            {
            //                if (data.Columns.Contains(field.ValueMapColumn))
            //                {
            //                    bool isValid = true;
            //                    var requiredResult = requiredCheck.Verify(this.Context, field);
            //                    isValid &= requiredResult.IsValid;
            //                    result.Message += requiredResult.Message;
            //                    if (!field.IgnoreCtlVerify)
            //                    {
            //                        var controlCheckResult = field.ParaseControlVerify(Context.ConfigInfo.CheckWay).Verify(Context);
            //                        isValid &= controlCheckResult.IsValid;
            //                        result.Message += controlCheckResult.Message;
            //                    }
            //                    result.IsValid &= isValid;
            //                    if (!isValid)
            //                    {
            //                        if (Context.ConfigInfo.CheckWay == DataCheckWay.InDB)
            //                        {
            //                            Context.DbUpdatedColList.Add(VerifyResultColumns.IsValid);
            //                        }
            //                        else
            //                        {
            //                            Context.MemoryUpdatedColList.Add(VerifyResultColumns.IsValid);
            //                        }
            //                    }
            //                }
            //            }
            //            catch (Exception e)
            //            {
            //                throw new Exception("字段:" + field.DisplayName + " " + e.Message);
            //            }
            //        }
            //        // 其他的字段规则
            //        var fieldResult = RunByRuleType(data, RuleTypeEnum.FieldRule, false);
            //        result.Message += fieldResult.Message;
            //        RuleContext.Log.Info("field verify end.");

            //        // 非法且没有异常消息
            //        if (!result.IsValid && string.IsNullOrEmpty(result.Message))
            //        {
            //            result.Message = "在进行字段校验时，发现不合法的数据;";
            //        }

            //        // 用默认值填充不可见，可用的字段
            //        //FillInvisibleDefaultData();
            //        // second: do successor verify
            //        if (null != successor)
            //        {
            //            var successorResult = this.successor.VerifyData();
            //            result.Message += successorResult.Message;
            //        }
            //    }
            //    else
            //    {
            //        result.Message = "没有需要校验的字段，请检测配置的字段定义;";
            //    }
            //}
            //else
            //{
            //    result.Message = "数据列表为空，不需要进行校验;";
            //}
            //result.IsValid = string.IsNullOrEmpty(result.Message);
            //return result;

        }
    }
}
